﻿//#include<iostream>
//using namespace std;
//void add(int m, int n = 10)
//{
//	cout << m + n << endl;
//}
//int main()
//{
//	int m= 55;
//
//	add(m);
//	return 0;
//}
//
//#include<iostream>
//using namespace std;
////struct A {
////
////	long a1;
////
////	short a2;
////
////	int a3;
////
////	int* a4;
////
////};
////int main()
////{
////	cout << sizeof A << endl;
////	return 0;
////}
//
////void SWAP(int a ,int b)
////{
////	int ans = 0;
////	ans = a;
////	a = b;
////	b = ans;
////}
//
//	//int& Add(int a, int b)
//	//{
//	//	int c = a + b;
//	//	return c;
//	//}
//
//	//int main()
//	//{
//	//	int& ret = Add(1, 2);
//	//	Add(3, 4);
//	//	cout << "Add(1, 2) is :" << ret << endl;
//	//	return 0;
//	//}
////class aa
////{
////public:
////	void f();
////private:
////	int a;
////	int b;
////};
////
////void aa::f()
////{
////	cout << "world " << endl;
////}
////void f()
////{
////	cout << "hehe" << endl;
////}
////int main()
////{
////	aa c;
////
////	f();
////    c.f();
////
////	return 0;
////}
//
//class Date
//
//{
//
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//	
//
//private:
//	int _year; 
//
//	int _month; 
//
//	int _day; 
//
//};
//
//int main()
//{
//	Date d1, d2;
//	d1.Init(2022, 1, 11);
//	d2.Init(2022, 1, 12);
//	d1.Print();
//	d2.Print();
//	return 0;
//}
//#include<iostream>
//using namespace std;
//class TIME
//{
//public:
//	TIME()
//	{
//		cout << "TIME()" << endl;//这里如果出现 则说明编译器调用了 TIME的构造函数
//		_hour = 0;
//		_minute = 0;
//		_second = 0;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class date 
//{
//private:
//	//基本内置类型
//	int _year = 2024;
//	int _month = 4;
//	int _day = 30;
//	//自定义类型
//	TIME _T;
//};
//int main()
//{
//	date d1;
//	
//	return 0;
//}

//#include<iostream>
//using namespace std;
//typedef int datatype;
//class Stack
//{
//public:
//	Stack(size_t capacity = 3)
//	{
//		cout << "Stack()" << endl;
//		_array = (datatype*)malloc(sizeof(datatype)*capacity);
//		if (_array == 0)
//		{
//			perror("malloc fail");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//
//	}
//	void push(datatype data)
//	{
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()//析构函数
//	{
//		cout << "~stack" << endl;
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	datatype* _array;
//	int _capacity;
//	int _size;
//};
//
//class myqueue
//{
//private:
//	Stack s1;
//	Stack s2;
//	int _size = 0;
//};
//int main()
//{
//	myqueue q;
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//class Date
//
//{
//
//public:
//	Date(int year = 1 , int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		cout << _year << "-" <<_month << "-" <<_day << endl;
//	}
//
//	Date operator= (const Date & d1)
//	{
//		_year = d1._year;
//		_month = d1._month;
//		_day = d1._day;
//		return *this;
//	}
//
//	bool operator> ( const Date& dt2)
//	{
//		if (_year > dt2._year)
//		{
//			return true;
//		}
//		else if (_year == dt2._year)
//		{
//			if (_month > dt2._month)
//			{
//				return true;
//			}
//			else if (_month == dt2._month)
//			{
//				return _day > dt2._day;
//
//			}
//		}
//		return false;
//	}
//
//private:
//	int _year = 1;
//
//	int _month = 1;
//
//	int _day = 1;
//	
//};
////bool operator> ( const Date & dt1,const Date & dt2)
////{
////	if (dt1._year > dt2._year)
////	{
////		return true;
////	}
////	else if (dt1._year == dt2._year)
////	{
////		if (dt1._month > dt2._month)
////		{
////			return true;
////		}
////		else if (dt1._month == dt2._month)
////		{
////			return dt1._day > dt2._day;
////
////		}
////	}
////	return false;
////}
//Date & func()
//{
//	Date d;
//	return d;
//
//}
//int main()
//{
//	//Date d1(2024,5 ,5);
//	//Date d3 (2024,6,10);//这也是拷贝构造
//
//	//cout << (d1 > d3) << endl;//隐式调用 
//	//cout << (d1.operator> ( d3)) << endl;//显示调用
//	const Date & rwet = func();
//	return 0;
//}
//#include<iostream>
//#include<assert.h>
//using namespace std;
//class Date
//
//{
//
//public:
//
//	// 获取某年某月的天数
//
//	int GetMonthDay(int year, int month)
//	{
//		assert(month > 0 && month < 13);
//		static int montharray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
//
//		if (month == 2)
//	  
//			if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
//			{
//				return 29;
//			}
//	 
//	
//	 
//			return montharray[month];
//   	}
//
//	//int GetMonthDay(int year, int month)
//	//{
//	//	assert(month > 0 && month < 13);
//
//	//	static int monthDayArray[13] = { -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//
//	//	// 365天 5h +
//	//	if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
//	//	{
//	//		return 29;
//	//	}
//	//	else
//	//	{
//	//		return monthDayArray[month];
//	//	}
//	//}
//
//	// 全缺省的构造函数
//
//	Date(int year = 1900, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//
//
//	// 拷贝构造函数
//
//  // d2(d1)
//
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//
//
//	// 赋值运算符重载
//
//  // d2 = d3 -> d2.operator=(&d2, d3)
//
//	Date& operator=(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//
//		return *this;
//	}
//
//
//
//	// 析构函数
//
//	~Date()
//	{
//		_year = -1;
//		_month = -1;
//		_day = -1;
//	}
//
//
//	// 日期+=天数
//
//	Date operator+(int day)
//	{
//		Date tmp = *this;
//		//tmp._day += day;
//		/*while (tmp._day > GetMonthDay(tmp._year, tmp._month))
//		{
//			tmp._day -= GetMonthDay(tmp._year, tmp._month);
//			++tmp._month;
//			if (tmp._month == 13)
//			{
//				++tmp._year;
//				tmp._month = 1;
//			}
//		}*/
//		tmp += day;
//
//		return tmp;
//	}
//
//
//
//	// 日期+天数
//	//使用进位进行相加
//	Date & operator+=(int day)
//	{
//		if (day < 0)
//		{
//			return *this -= -day;
//		}
//		_day += day;
//		while (_day > GetMonthDay(_year , _month))
//		{
//			_day -= GetMonthDay(_year , _month);
//			++_month;
//			if (_month == 13)
//			{
//				++_year;
//				_month = 1;
//			}
//		}
//		return *this;
//	}
//
//
//
//	// 日期-天数
//
//	Date operator-(int day)
//	{
//		Date tmp = *this;
//		tmp -= day;
//		return tmp;
//	}
//
//
//
//	// 日期-=天数
//
//	Date& operator-=(int day)
//	{
//		if (day < 0)
//		{
//			return *this += -day;
//		}
//		_day -= day;
//		while (_day <= 0)
//		{
//			--_month;
//			if (_month == 0)
//			{
//				_month = 12;
//				_year--;
//			}
//			_day += GetMonthDay(_year, _month);
//		}
//		return *this;
//	}
//
//
//
//	// 前置++
//
//	Date& operator++()
//	{
//		*this += 1;
//		return *this;
//	}
//
//
//
//	// 后置++
//
//	Date operator++(int)
//	{
//		Date tmp = *this;
//		*this += 1;
//		return tmp;
//	}
//
//
//
//	// 后置--
//
//	Date operator--(int)
//	{
//		Date tmp = *this;
//		*this -= 1;
//		return tmp;
//	}
//
//
//
//	// 前置--
//
//	Date& operator--()
//	{
//		*this -= 1;
//		return *this;
//	}
//
//
//
//	// >运算符重载
//
//	bool operator>(const Date& d)
//	{
//		if (this->_year > d._year)
//		{
//			return true;
//		}
//		else if (this->_year == d._year)
//		{
//			if (this->_month > d._month)
//			{
//				return true;
//			}
//			else if (this->_month == d._month)
//			{
//				return this->_day > d._day;
//			}
//		}
//		return false;
//	}
//
//
//	// ==运算符重载
//
//	bool operator==(const Date& d)
//	{
//		return this->_year == d._year
//			&& this->_month == d._month
//			&& this->_day == d._day;
//	}
//
//
//
//	// >=运算符重载
//
//	bool operator >= (const Date& d)
//	{
//		return *this > d || *this == d;
//	}
//
//
//	// <运算符重载
//
//	bool operator < (const Date& d)
//	{
//		return !(*this >= d);
//	}
//
//
//	// <=运算符重载
//
//	bool operator <= (const Date& d)
//	{
//		return *this < d || *this == d;
//	}
//
//
//	// !=运算符重载
//
//	bool operator != (const Date& d)
//	{
//		return !(*this == d);
//	}
//
//
//	// 日期-日期 返回天数
//
//	int operator-(const Date& d)
//	{
//		Date maxx = *this;
//		Date minn = d;
//		int flag = 1;
//		if (*this < d)
//		{
//			flag = -1;
//			maxx = d;
//			minn = *this;
//		}
//		int n = 0;
//		while (minn != maxx)
//		{
//			++n;
//			++minn;
//		}
//
//		return n * flag;
//	
//	}
//
//	void print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//
//	int _year;
//
//	int _month;
//
//	int _day;
//
//};
//
//int main()
//{
//	Date d1(2024 ,4 ,14);
//	Date d2(2024, 5, 1);
//	/*Date d2 = d1--;
//	d1.print();
//	d2.print();*/
//
//	int n = d1 - d2;
//
//	cout << n << endl;
//
//	return 0;
//}
//#include<stdio.h>
//int main()
//{
//	int year = 0;
//	scanf("%d", &year);
//	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
//		printf("是闰年\n");
//
//	return 0;
//typedef int datatype;
//class Stack
//{
//public:
//	Stack(size_t capacity = 3)
//	{
//		cout << "Stack()" << endl;
//		_array = (datatype*)malloc(sizeof(datatype)*capacity);
//		if (_array == 0)
//		{
//			perror("malloc fail");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//
//	}
//	void push(datatype data)
//	{
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()//析构函数
//	{
//		cout << "~stack" << endl;
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	datatype* _array;
//	int _capacity;
//	int _size;
//};
//
//class MYQUEUE
//{
//public:
//	stack类中如果不具备默认构造，myqueue也无法生成默认构造
//	MYQUEUE()
//		:_size(1)
//		,_ptr((int*)malloc(40))
//	{
//		memset(_ptr,1,40);
//	}
//		
//
//private:
//	/*Stack _pushst;
//	Stack _popst;*/
//	int _size = 0; 
//	int* _ptr;
//};
//int main()
//{
//	MYQUEUE q;
//	return 0;
//}
//
//class A
//{
//public:
//	//A(int a)//单参构造函数
//	//	:_a(a)
//	//	
//	//{}
//
//	A(int a,int a1,int a2)//多参构造函数
//		:_a(a)
//		,_a2(a1)
//		,_a3(a2)
//	{}
//private:
//	int _a;
//	int _a2;
//	int _a3;
//};
//class stack
//{
//public:
//	void push(const A & aa)
//	{
//	}
//};
//int main()
//{
//	stack st;
//	A aa1 = { 1,2,3 };
//	st.push(aa1);
//
//	st.push({ 1,2,3 });//这里没有先调用push 而是先调用构造函数去创建临时变量 之后在调用push函数
//	return 0;
//}

//class A
//
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	A& operator= (const A& aa)
//	{
//		cout << "A& operator= (const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a = aa._a;
//		}
//		return *this;
//	}	
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//private:
//	int _a;
//};
//void f1(const A  aa)
//{
//
//}
//A f2()
//{
//	A aa1;
//	return aa1;
//}
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new A(2);//这里有new修饰 这里不是匿名对象
//
//	delete p1;
//	delete p2;
//	cout << endl;
//
//	A* p3 = new A[10];
//	delete[] p3;
//
//	A* p4 = new A[10]{1,2,3,4,5,6};
//	delete[] p4;
//	return 0;
//}
//
//int main()
//{
//	int* p1 = new int(1);
//	int* p2 = new int[10] {1,2,3,4,5,6};//开10空间
//
//
//	delete p1;
//	delete[] p2;//销毁多空间时使用
//	return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//
//void bj(int arr[], int r)
//{
//	int count[100] = { 0 };
//	int sc[10];
//
//	for (int i = 0; i < r; i++)// 统计每个整数出现的次数
//	{
//		count[arr[i]]++;
//	}
//
//	for (int i = 1; i <= r; i++) // 将计数数组转换为前缀和数组
//	{
//		count[i] += count[i - 1];
//	}
//
//	for (int i = r - 1; i >= 0; i--)// 将元素放入输出数组中，并更新计数数组
//	{
//		sc[count[arr[i]] - 1] = arr[i];
//		count[arr[i]]--;
//	}
//
//	for (int i = 0; i < r; i++)// 将排序后的数组拷贝回原数组
//	{
//		arr[i] = sc[i];
//	}
//
//}
//
//int main()
//{
//	int n;
//	int k;
//	printf("请输出n的值:");
//	scanf("%d", &n);
//	printf("请输出k的值:");
//	scanf("%d", &k);
//	int e = 0;
//	while (e < k)
//	{
//		int s[10] = { 0 };
//		int f[10] = { 0 };
//		printf("输入数值到s%d:", e + 1);
//		for (int j = 0; j < n; j++)
//		{
//			scanf("%d", &f[j]);
//			if (f[j] <= n && f[j] >= 1)
//			{
//				s[j] = f[j];
//			}
//		}
//
//		bj(s, n);
//
//		printf("输出s%d的值:", e + 1);
//
//		for (int j = 0; j < n; j++)
//		{
//			printf("%d", s[j]);
//		}
//		printf("\n");
//		e++;
//	}
//
//	return 0;
//}

//#include <iostream>
//#include <cstdlib>
//
//using namespace std;
//
//void test() {
//    int* ptr4 = new int; // 动态申请内存
//    int* ptr5 = new int(10); // 动态申请内存并初始化
//    int* ptr6 = new int[10]; // 动态申请内存
//
//    // 使用完毕后释放内存
//    delete ptr4;
//    delete ptr5;
//    delete[] ptr6;
//}
//
//int main() {
//    test();
//    return 0;
//}
//#include<iostream>
//#include<cstdlib>
//using namespace std;//动态申请空间
//
//
//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A()" << this << endl;
//	}
//
//	~A()
//	{
//		cout << "~A()" << this << endl;
//	}
//
//private:
//	int _a;
//
//};
//
//int main()
//{
//	A* p1 = (A*)malloc(sizeof(A));
//	A* p2 = new A(1);
//	free(p1);
//	delete p2;
//	//new/delete和 malloc/free最大区别是 new/delete对于自定义类型	除了会开空间还会调用构造函数和析构函数
//
//	cout << endl;
//
//	int* p3 = (int*)malloc(sizeof(int));
//	int* p4 = new int;
//	free(p3);
//	delete p4;
//
//	cout << endl;
//
//	A* p5 = (A*)malloc(sizeof(A)*10);
//	A* p6 = new A[10];
//	free(p5);
//	delete[] p6;
//
//	return 0;
//}//在申请自定义类的空间时 new会调用构造函数 delete会调用析构函数 而malloc和free不会调用

 //new和delete是用户进行动态内存申请和释放的操作符 operator new 和 operator delete是系统提供的全局函数 new在底层调用operator new来申请空间， delete在底层调用 operator delete 来释放空间

//operator new 该函数实际通过malloc来申请空间，当malloc申请空间成功则直接返回，如果申请空间失败，尝试执行空间不足应对措施 如果该应对措施用户设置了 则继续申请 否则抛出异常

//
//#include<iostream>
//using namespace std;//动态申请空间
//
//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A()" << this << endl;
//	}
//
//	~A()
//	{
//		cout << "~A()" << this << endl;
//	}
//
//private:
//	int _a;
//};
//
////定位new/replacement new
//int main()
//{
// //p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
//	A* p1 = (A*)malloc(sizeof(A));
//	new(p1)A;
//	p1->~A();
//	free(p1);
//
//	A* p2 = (A*)operator new(sizeof(A));
//	new(p2)A(10);
//	p2->~A();
//
//	operator delete (p2);
//	return 0;
//}
//void SWAP(int &left,int &right)
//{
//	int temp = left;
//	left = right;
//	right = temp;
//}
//
//void SWAP(double& left, double& right)
//{
//	double temp = left;
//	left = right;
//	right = temp;
//}
//
//void SWAP(char& left, char& right)
//{
//	char temp = left;
//	left = right;
//	right = temp;
//}
//
//
//template<typename T>
//void Swap(T& left,T &right)
//{
//	T temp = left;
//	left = right;
//	right = temp;
//
//}
//
//int main()
//{
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//template<typename T>
//T add(const T& left,const T& right)
//{
//	return left + right;
//}

//int main()
//{
//	int a1 = 10, a2 = 20;
//	double d1 = 10.0, d2 = 20.0;
//	add(a1,a2);
//	add(d1,d2);
//	return 0;

	//该语句不能通过编译，因为在编译期间 当编译器看到该实例化时，需要推演其实参类型，通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模版参数列表中只有一个T
	//编译器无法确定此处到底该将T推演int还是double类型而导致编译失败
	//解决方法 1.用户强制转换类型，2.使用显式实例化
	//add(a1,d1);
//}
//
//int main()
//{
//	int a = 10;
//	double b = 10.0;
//	add(a,(int)b);//如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器户会报错
//	return 0;
//}
//
//int add(int	left, int right)
//{
//	return left + right;
//}
//
//template<class T>	
//T add(T left, T right)
//{
//	return left + right;
//}
//
//void test()
//{
//	add(1, 2);//非模版版本
//	add<int>(1, 2);//模版版本
//}
//
//#include<iostream>
//#include<string>
//using namespace std;
//template<class T>
//class Vector
//{
//public:
//	Vector(size_t capacity = 10)
//		:_PDATA(new T[capacity])
//		, _SIZE(0)
//		, _CAPACITY(CAPACITY)
//	{}
//
//	~Vector();
//	void PushBack(const T& data);
//	void PopBack();
//		// ...
//	T& operator[](size_t pos)
//		size_t Size() { return _size; }
//		{
//			assert(pos < _size);
//			return _pData[pos];
//		}
//
//private:
//	T* _pData;
//	size_t _size;
//	size_t _capacity;
//
//};
//
//// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
//template <class T>
//Vector<T>::~Vector()
//{
//	if (_pData)
//		delete[] _pData;
//	_size = _capacity = 0;
//}
//
//
//// Vector类名，Vector<int>才是类型
//Vector<int> s1;
//Vector<double> s2;


// 实现两个字符的数字相加后和的字符

//class Solution {
//public:
//	string addStrings(string num1, string num2) {
//		int i = num1.length() - 1; int j = num2.length() - 1; int add = 0;
//		string ans = "";
//		while (add != 0 || i >= 0 || j >= 0)
//		{
//			int x = i >= 0 ? num1[i] - '0' : 0;
//			int y = j >= 0 ? num2[j] - '0' : 0;
//			int result = x + y + add;
//			ans.push_back('0' + result % 10);
//			add = result / 10;
//			i--;
//			j--;
//		}
//		reverse(ans.begin(), ans.end());
//		return ans;
//	}
//};
//
//int main()
//{
//	return 0;
//}

//#define _CRT_SECURE_NO_WARNINGS 1
//
//#include<iostream>
//#include<string>
//#include<algorithm>
//using namespace std;
//void string1()
//{
//	string s;//默认构造一个空的string类
//	string s1("hello world");//带参构造
//	string s2(s1);//拷贝构造
//
//	cout << s << endl;  //重载流插入
//	cout << s1 << endl;
//	cout << s2 << endl;
//
//	cin >> s;//重载流提取
//	cout << s << endl;
//}
//
//void string2()
//{
//	
//	string s1("hello world");//带参构造
//	string s2(s1, 3, 5);//部分访问构造 从s1中的第三个位置之后取五个字符进行构造
//	string s3(s1, 3);
//	string s4(s1,3,100);
//	cout << s1 << endl;
//	cout << s2 << endl;
//	cout << s3 << endl;
//	cout << s4 << endl;
//}
//
//void string3()
//{
//	string s1("hello world", 5);
//	cout << s1 << endl;
//	
//}
//void string4()
//{
//	string s1(10,'x');
//	cout << s1 << endl;
//
//}
//
//void string5()
//{
//	string s1 = "hello world";//隐式类型转换
//	中间会产生临时变量 具有常性
//
//	const string& s2 = "hello world" ;//引用这种需要用const修饰
//}
//void string6()
//{
//	string s1("hello world");
//	cout << s1.size()<<endl;
//	cout << s1.length() << endl;
//	cout << s1.max_size() << endl;
//}
//
//void string7()
//{
//  	const string s1 = "hello world";
//	
//
//	string::const_iterator it1 = s1.begin();
//	while (it1 != s1.end())
//	{
//		cout << (*it1) << " ";
//		++it1;
//	}
//	cout << endl;
//	
//}
//
//void string8()
//{
//  string s1 = "hello world";
//  sort(s1.begin(),s1.end());
//  auto e = s1.begin();
//  while (e != s1.end())
//  {
//	  cout << *e ;
//	  ++e;
//  }
//  cout << endl;
//
//}
//
//void string9()
//{
//	string s1 = "hello world";
//	cout << s1 << endl;
//
//	s1.push_back('x');
//	cout << s1 << endl;
//
//	s1.append("yyyyyyyyy?");
//	cout << s1 << endl;
//
//	string s2 = "8888888";
//	s1 += 'y';
//	s1 += "6666666";
//	s1 += s2;
//	cout << s1 << endl;
//}
//void string10()
//{
//	string s1 = "hello world";
//	cout << s1 << endl;
//	s1.insert(0,"xxxxxx");
//	cout << s1 << endl;
//	/*s1.insert(0,2,'c');
//	cout << s1 << endl;
//	s1.insert(s1.begin(),'r');
//	cout << s1 << endl;*/
//	string s2;
//	s2.insert(s2.begin(),s1.begin(),s1.end()-1);
//	cout << s2 << endl;
//}
//void string11()
//{
//	string s1("hello world");
//	cout << s1 << endl;
//	s1.assign("2222222");
//	cout << s1 << endl;
//}
//void string12()
//{
//	string s1("hello world");
//	cout << s1 << endl;
//	s1.erase(5,200);
//	cout << s1 << endl;
//	s1.erase(0,1);
//	cout << s1 << endl;
//
//}
//void string13()
//{
//	/*string s1("hello world");
//	cout << s1 << endl;
//	s1.replace(5,1,"%20");
//	cout << s1 << endl;*/
//	string s2("hello world helloc bit");
//	cout << s2 << endl;
//	for (int i = 0 ; i< s2.size();)
//	{
//		if (s2[i]==' ')
//		{
//			s2.replace(i,1,"%20");
//			i += 3;
//		}
//		else
//		{
//			i++;
//		}
//	}
//	cout << s2 << endl;
//}
//void string14()
//{
//	string s3;
//	string s2("hello world helloc bit");
//	cout << s2 << endl;
//	for (auto e:s2)
//	{
//		if (e != ' ')
//		{
//			s3 += e;
//		}
//		else
//		{
//			s3 += "%20";
//		}
//	}
//	cout << s3 << endl;
//}
//
//void string15()
//{
//	
//	string s2("hello world helloc bit");
//	cout << s2.size() << endl;
//	cout << s2.capacity() << endl;
//	cout << s2.max_size() << endl;
//}
//
//void string16()
//{
//	string s1("1111111111");
//	string s2("11111111111111111111111111");
//	cout << s1.capacity() << endl;
//	s1.reserve(100);
//	cout << s1.capacity() << endl;
//	s1.reserve(10);
//	cout << s1.capacity() << endl;
//}
//void string17()
//{
//	/*string s1;
//	s1.resize(5,'0');
//	s1[4] = '7';
//	s1[3] = '6';
//	s1[2] = '5';
//	s1[1] = '4';
//	s1[0] = '3';
//	cout << s1 << endl;*/
//
//	string s2("hello world");
//
//	
//	s2.resize(5);
//
//	try
//	{
//		s2.at(10);
//	}
//	catch (const exception&e)
//	{
//		cout << e.what() << endl;
//	}
//	
//}
//void string18()
//{
//	string file("1111.cpp");
//	FILE* fout = fopen(file.c_str(),"r");
//	char ch = fgetc(fout);
//	while (ch!=EOF)
//	{
//		cout << ch;
//		ch = fgetc(fout);
//	}
//}
//
//void string19()
//{
//	string s1("string.cpp.zip");
//	size_t pos = s1.find('.');
//	string s2;
//	s2 = s1.substr(pos,2);
//	cout << s2 << endl;
//}
//void string20()
//{
//	string s1("https://gitee.com/bitpg/class112--c-training-camp-2");
//	size_t pos1 = s1.find(':');
//	string s2 = s1.substr(0,pos1-0);
//	cout << s2 << endl;
//
//	size_t pos2 = s1.find('/',pos1+3);
//	string s3 = s1.substr(pos1+3,pos2-(pos1+3));
//	cout << s3 << endl;
//
//	string s4 = s1.substr(pos2+1);
//	cout << s4 << endl;
//}
//
//void string21()
//{
//	string str("5641635146541531513");
//	size_t found = str.find_first_of("567");
//	while (found != std::string::npos)
//	{
//		str[found] = '*';
//		found = str.find_first_of("567",found+1);
//	}
//	cout << str << endl;
//}
//void string22()
//{
//	string s1 = ("546548749");
//	string s2 = ("54657777");
//	cout << (s1 <s2) << endl;
//}
//void string23()
//{
//	int x;
//	int y;
//	cin >> x >> y;
//	string s1 = to_string(x+y);
//	cout << s1 << endl;
//}
//int main()
//{
//	string23();
//	return 0;
//} 
// 
//#include<iostream>
//#include<algorithm>
//using namespace std;
//#include<vector>
//#include<string>
//void vector1()
//{ 
//	/*vector<int> v1;
//	vector<double> v1;
//	vector<char> v1;
//	vector<vector<int>> v1;
//	vector<string> v1;*/
//	
//
//}
//void vector2()
//{
//	vector<int>v1;
//	v1.push_back(1);
//	v1.push_back(2);
//	v1.push_back(1);
//	v1.push_back(5);
//	v1.push_back(6);
//	v1.push_back(1);
//	/*for (size_t i = 0; i < v1.size(); i++)
//	{
//		cout << v1[i] << " ";
//	}
//	cout << endl;*/
//	/*vector<int>::iterator e = v1.begin();
//	while (e!=v1.end())
//	{
//		cout << *e << " ";
//		e++;
//	}
//	cout << endl;*/
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void vector3()
//{
//	vector<string>v1;
//	string s1("张三");
//	v1.push_back(s1);//有名对象
//
//	v1.push_back(string("呵呵"));//匿名对象
//
//	v1.push_back("哈哈");//隐式类型转换  这里有问题
//
//	for (const auto & e : v1)//string类型的vector遍历这里可以修改一下
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void vector4()
//{
//	vector<int>v1;
//	v1.push_back(1);
//	v1.push_back(2);
//	v1.push_back(12);
//	v1.push_back(5);
//	v1.push_back(6);
//	v1.push_back(10);
//	v1.push_back(100);
//	v1.push_back(19);
//	v1.push_back(41);
//	v1.push_back(55);
//	v1.push_back(7);
//	greater<int>gt;//仿函数
//	sort(v1.begin(),v1.end(),gt);
//	//sort(v1.begin()+1,v1.end()-1);
//	//greater<int>gt;//仿函数
//	//sort(v1.begin(),v1.begin()+v1.size()/2,gt);//这里根据改变参数来改变排序范围 非常灵活
//	for (auto e:v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//}
//void vector5()
//{
//	greater<int> gt;//这个仿函数是这个类型的对象 可以支持比较大小
//	cout<<gt(3,2)<<endl;
//	cout << gt.operator()(3, 2) << endl;//为什么这个对象能够像函数一样去调用的本质
//cout<<	gt(2,3)<<endl;
//
//}
//int main()
//{
//	vector5();
//	
//	return 0;
//}

//#include<iostream>
//#include<algorithm>
//
//using namespace std;
//#include<vector>
//#include<list>
//void list1()
//{
//	list<int>l1 = { 1,2,3,4,5,6 ,1,3,4};
//	list<int>::iterator it = l1.begin();
//	while(it != l1.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//	//sort(l1.begin(),l1.end());
//	l1.sort();
//	list<int>::iterator it1 = l1.begin();
//
//	while (it1 != l1.end())
//	{
//		cout << *it1 << " ";
//		it1++;
//	}
//	cout << endl;
//	//greater<int>gt;
//	l1.sort(greater<int>());
//	for (auto e:l1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	l1.unique();
//	for (auto e : l1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void vector6()
//{
//	
//	
//		// constructors used in the same order as described above:
//		vector<int> first;                                // 构造空vector对象
//		vector<int> second(4, 100);                       // 进行构造同时进行初始化 这里生成的对象会有4个100的元素
//		vector<int> third(second.begin(), second.end());  // 这里是使用second对象的迭代器进行初始化
//		vector<int> fourth(third);          // 拷贝构造
//		int myints[] = { 16,2,77,29 };
//		std::vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int)); 
//
//}
//void vector7()
//{
//	std::vector<int> myvector;
//
//	// set some initial content:
//	for (int i = 1; i < 10; i++) myvector.push_back(i);
//
//	myvector.resize(5);
//	myvector.resize(8, 100);
//	myvector.resize(12);
//
//	std::cout << "myvector contains:";
//	for (int i = 0; i < myvector.size(); i++)
//		std::cout << ' ' << myvector[i];
//	std::cout << '\n';
//}
//
//void vector8()
//{
//	vector<int>v1;
//	v1.push_back(1);
//	v1.push_back(2);
//	v1.push_back(1);
//	v1.push_back(5);
//	v1.push_back(6);
//	v1.push_back(1);
//	/*for (size_t i = 0; i < v1.size(); i++)
//	{
//		cout << v1[i] << " ";
//	}
//	cout << endl;*/
//	/*vector<int>::iterator e = v1.begin();
//	while (e!=v1.end())
//	{
//		cout << *e << " ";
//		e++;
//	}
//	cout << endl;*/
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	v1.pop_back();
//	v1.pop_back();
//	v1.pop_back();
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void vector9()
//{
//	vector<int>v1;
//	v1.push_back(1);
//	v1.push_back(2);
//	v1.push_back(1);
//	v1.push_back(5);
//	v1.push_back(6);
//	v1.push_back(1);
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	v1.insert(v1.begin(), 5); //插入一个数据
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	v1.insert(v1.begin(), 5,100);//填充
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	vector<int> vv;
//	vv.insert(vv.begin(),v1.begin(),v1.end());//范围插入
//	for (auto e : vv)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void vector10()
//{
//	int myints[] = { 10, 20, 30, 40 };
//	int* p;
//
//	p = std::find(myints, myints + 4, 30);
//	if (p != myints + 4)
//		std::cout << "Element found in myints: " << *p << '\n';
//	else
//		std::cout << "Element not found in myints\n";
//
//	// using std::find with vector and iterator:
//	std::vector<int> myvector(myints, myints + 4);
//	std::vector<int>::iterator it;
//
//	it = find(myvector.begin(), myvector.end(), 30);
//	if (it != myvector.end())
//		std::cout << "Element found in myvector: " << *it << '\n';
//	else
//		std::cout << "Element not found in myvector\n";
//
//}
//int main()
//{
//	vector10();
//	return 0;
//}
//#include<iostream>
//#include<algorithm>
//
//using namespace std;
//#include<list>
//void list1()
//{
//	list<int>l1 = { 1,2,3,4,5,6 ,1,3,4};
//	list<int>::iterator it = l1.begin();
//	while(it != l1.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//	//sort(l1.begin(),l1.end());
//	l1.sort();
//	list<int>::iterator it1 = l1.begin();
//
//	while (it1 != l1.end())
//	{
//		cout << *it1 << " ";
//		it1++;
//	}
//	cout << endl;
//	//greater<int>gt;
//	l1.sort(greater<int>());
//	for (auto e:l1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	l1.unique();//去重
//	for (auto e : l1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void list2()
//{
//
//	std::list<int> mylist1, mylist2;
//	std::list<int>::iterator it;
//
//	// set some initial values:
//	for (int i = 1; i <= 4; ++i)
//		mylist1.push_back(i);      // mylist1: 1 2 3 4
//
//	for (int i = 1; i <= 3; ++i)
//		mylist2.push_back(i * 10);   // mylist2: 10 20 30
//
//	it = mylist1.begin();
//	++it;                         // points to 2
//
//	mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
//	for (auto e:mylist1)//拼接 转移  将一个迭代器范围内的list内容转移到pos位置的list容器中 并且被转移的内容在原来的list容器是不会再出现的
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//void list3()
//{
//	list<int> mylist1;
//	for (int i = 1; i <= 4; i++)
//		mylist1.push_back(i);
//	auto it = find(mylist1.begin(),mylist1.end(),3);//find使用的algorithm库中的 第一个参数和第二个参数是迭代器用来确定查找的范围 第三个参数是要查找的内容  最后会返回找到位置的迭代器
//	mylist1.splice(mylist1.begin() , mylist1,it);
//	for (auto e : mylist1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//int main()
//{
//	list3();
//	return 0;
//}
//#include<iostream>
//using namespace std;
//#include<stack>
//#include<queue>
//
//void stack1()
//{
//	stack<int>s;
//	s.push(1);
//	s.push(10);
//	s.push(11);
//	s.push(12);
//	s.push(13);
//	s.push(14);
//	while (!s.empty())//取栈顶数据 后进先出
//	{
//		cout << s.top() << " ";
//		s.pop();
//	}
//	cout << endl;
//	
//}
//int main()
//{
//	stack1();
//	return 0;
//}//访问容器迭代器 一.封装提供了统一的访问容器的方式 学起来简单切易记忆 
////二.封装屏蔽了底层实现的细节
//

//#include<iostream>
//
//using namespace std;
//#include<array>
////c++20之前 只允许整型做非法类型模版参数
////c++20之后 可以允许（double）等其他内置类型
//template<class T , size_t N = 10 >//进行非类型的模版参数实例
//class stack
//{
//public:
//	void func()//按需实例化 在没有使用的地方也就不会进行实例化 没有实例化 就不会对语法进行检查
//	{
//		N++;
//	}
//private:
//
//    T _a[N] ;
//	T _top;
//};
//
//int main()
//{
//	array<int, 10> aa;//静态数组空间
//	cout << sizeof(aa) << endl;
//
//
//	int aa2[10];//动态数组 对比
//
////这里最大的区别是检查越界 
//	aa2[12] = 1;//在这里 10 和11 两个越界位置可以检查出来 但是到了12就再无法检查出来了
//	//这里是考虑成本问题 设置标志位置 进行抽查  且在调试时发现只有编译完成时 才会报错
//	//而array静态数组 则一旦越界就可以检测到 进行严格的越界检查
//	//而array 也是不会进行初始化 只是负责把空间开出来  且还有一个弊端 array不是开在堆上的空间 是直接开在栈针上的
//
//	//而且vector完全可以很好的替代array 所以array是一个鸡肋的设计
//
//	//stack<int> s;
//	//stack<int, 10> s1;//
//	//stack<int, 100>s2;
//	//
//	return 0;
//}
//#include<iostream>
//using namespace std;
//#include<vector>
//template <class T>
//void printvector(const vector<T>& v)
//{
//	//typename vector<T>::const_iterator it = v.begin();//这里为什么非要加typename
//	auto it = v.begin();//这里使用auto也能避开问题 因为auto一定是类型
//	while (	it!= v.end()) //根据按需实例化 在类模版中没实例化时 不去里面查细节东西    所以在遍历去取的时候类域vector<T>无法确认是类型还是静态变量  所以需要手动添加typename来确认这里是类型
//	{
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//}
//int main()
//{
//	vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
//	vector<double> v2{ 1.1,1.2,1.3,1.4,1.5,1.6 };
//	printvector(v1);
//	printvector(v2);
//	return 0;
//}//typedef只能取类型  对变量取别名需要引用 

//#include<iostream>
//using namespace std;
//#include<vector>

//template<class T>
//
//bool Less(T left, T right)
//{
//	return left < right;
//}
////对于普通的类型比较大小是没有问题的 但是如果是指针的话 就会比较指针的大小 这样不符合逻辑 所以就设计模版特化、
////这样当是普通类型走上面 如果是日期类指针走特化
//
//// 对Less函数模板进行特化
//
//template<>
//
//bool Less<Date*>(Date* left, Date* right)
//{
//	return *left < *right;
//}
//
//int main()
//{
//	cout << Less(1, 2) << endl;
//
//	Date d1(2022, 7, 7);
//	Date d2(2022, 7, 8);
//	cout << Less(d1, d2) << endl;
//
//	Date* p1 = &d1;
//	Date* p2 = &d2;
//	cout << Less(p1, p2) << endl; 
//
//	return 0;
//}

//template<class T1, class T2>
//
//class Data
//
//{
//
//public:
//	Data() { cout << "Data<T1, T2>" << endl; }
//
//private:
//	T1 _d1;
//	T2 _d2;
//};
//
//
//template<>
//
//class Data<int, char>//全特化 
//
//{
//
//public:
//	Data() { cout << "Data<int, char>" << endl; }
//
//private:
//	int _d1;
//	char _d2;
//};
////这里是没有类重载的概念的
//
//// 将第二个参数特化为int
//
//template <class T1>
//
//class Data<T1, int>//班特化 偏特化
//
//{
//
//public:
//	Data() { cout << "Data<T1, int>" << endl; }
//
//private:
//	T1 _d1;
//	int _d2;
//};
//
//// 两个参数偏特化为指针类型
//
//template <typename T1, typename T2>
//
//class Data <T1*, T2*>//限定模版的类型 如果类型是指针 就会走这个 特化模版 且二级指针也会走这个模版
//{//这时限定的不是某个具体的类型 而是针对某一个大类 
//
//public:
//	Data() { cout << "Data<T1*, T2*>" << endl; }
//
//
//private:
//	T1 _d1; T2 _d2;
//};
//
//
//
//void TestVector()
//{
//	Data<int, int> d1;
//	Data<int, char> d2;
//}
//
//int main()
//{
//	TestVector();
//
//	return 0;
//}

//class Person
//
//{
//
//public:
// void Print()
// {
// cout << "name:" << _name << endl;
// cout << "age:" << _age << endl;
// }
//
//protected:
// string _name = "peter"; // 姓名
//
// int _age = 18; //年龄
//
//};
//
//// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//
////Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
////以看到变量的复用。调用Print可以看到成员函数的复用。
//
//class Student : public Person
//
//{
//
//protected:
//	int _stuid =2022151212; // 学号
//
//};
//class Teacher : public Person
//
//{
//
//protected:
//	int _jobid = 000000000000001; // 工号
//
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//	s.Print();
//	t.Print();
//	return 0;
//}
//#include<iostream>
//using namespace std;
//#include<vector>
//#include<queue>
//
//
//int main()
//
//{
//
//	queue<char> Q;
//
//	char x, y;
//
//	x = 'n'; y = 'g';
//
//	Q.push(x); Q.push('i'); Q.push(y);
//
//	Q.pop(); Q.push('r'); Q.push('t'); Q.push(x);
//
//	Q.pop(); Q.push('s');
//
//	while (!Q.empty())
//
//	{
//
//		x = Q.front();
//
//		Q.pop();
//
//		cout << x;
//
//	};
//
//	cout << y;
//	return 0;
//}



//#include <iostream>
//#include <list>
//using namespace std;
//
//int main()
//{
//	
//	std::list<int> first;                   //空构造           
//	std::list<int> second(4, 100);                  //4个值为100的构造   
//	std::list<int> third(second.begin(), second.end()); //范围构造
//	std::list<int> fourth(third);                      //拷贝构造
//
//	
//	int myints[] = { 16,2,77,29 };
//	std::list<int> fifth(myints, myints + sizeof(myints) / sizeof(int));//也可以使用其他容器进行范围构造
//
//	std::cout << "The contents of fifth are: ";
//	for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
//		std::cout << *it << ' ';
//
//	std::cout <<endl;
//
//	return 0;
//}


//#include <iostream>       // std::cout
//#include <stack>          // std::stack
//#include <vector>         // std::vector
//#include <deque>          // std::deque
//using namespace std;
//int main()
//{
//	deque<int> mydeque(3, 100);          // deque with 3 elements
//	vector<int> myvector(2, 200);        // vector with 2 elements
//
//	stack<int> first;                    // 构造空栈
//	stack<int> second(mydeque);         // 拷贝deque内容
//
//	stack<int, vector<int> > third;  // 使用vector容器的空栈
//	stack<int, vector<int> > fourth(myvector);//使用拷贝vector容器的栈
//
//	cout << "size of first: " << first.size() << '\n';
//	cout << "size of second: " << second.size() << '\n';
//	cout << "size of third: " << third.size() << '\n';
//	cout << "size of fourth: " << fourth.size() << '\n';
//
//	return 0;
//}

//int main()
//{
//	stack<int> s;
//	s.push(1);
//	s.push(10);
//	s.push(12);
//	s.push(14);
//	s.push(15);
//	s.push(16);
//	s.push(18);
//	s.push(19);
//	while (!s.empty())
//	{
//		int a = s.top();
//		cout << a << " ";
//		s.pop();
//	}
//	cout << endl;
//	return  0;
//}


//#include <iostream>       // std::cout
//#include <deque>          // std::deque
//#include <list>           // std::list
//#include <queue>          // std::queue
//using namespace std;
//int main()
//{
//	deque<int> mydeck(3, 100);        
//	list<int> mylist(2, 200);        
//
//	queue<int> first;                 //创建一个空队列
//	queue<int> second(mydeck);       //拷贝mydeck容器内容
//
//	queue<int,list<int> > third; //创建一个使用list容器的空队列
//	queue<int, list<int> > fourth(mylist);//创建一个使用list容器的队列并且将mylist的内容拷贝使用
//
//	cout << "size of first: " << first.size() << endl;
//	cout << "size of second: " << second.size() << endl;
//	cout << "size of third: " << third.size() << endl;
//	cout << "size of fourth: " << fourth.size() << endl;
//
//	return 0;
//}

//int main()
//{
//	queue<int> q;
//	q.push(1);
//	q.push(21);
//	q.push(31);
//	q.push(41);
//	q.push(51);
//	q.push(61);
//	q.push(71);
//
//	while (!q.empty())
//	{
//		int a = q.front();
//		cout << a << " ";
//		q.pop();
//
//	}
//	cout << endl;
//	return 0;
//}
//#include<iostream>
//using namespace std;
//#define N 100
//template<class T>//静态的栈 也就是要控制大小固定
//class stack
//{
//private:
//	int _a[N];
//	int _top;
//};
//int main()
//{
//	stack<int> s1;//10
//	stack<int>s2;//100
// 	return 0;
//}

//#include<iostream>
//#include<array>
//#include<vector>
//using namespace std;



//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//
//	bool operator<(const Date& d)const
//	{
//		return (_year < d._year) ||
//			(_year == d._year && _month < d._month) ||
//			(_year == d._year && _month == d._month && _day < d._day);
//	}
//
//	bool operator>(const Date& d)const
//	{
//		return (_year > d._year) ||
//			(_year == d._year && _month > d._month) ||
//			(_year == d._year && _month == d._month && _day > d._day);
//	}
//
//	friend ostream& operator<<(ostream& _cout, const Date& d);
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//template <class T>
//void printvector(vector<T> v)
//{
//	typename std::vector<T>::iterator it = v.begin();
//	auto it = v.begin();
//	while (it != v.end())
//	{
//		cout << *it << " ";
//		it++  ;
//	}
//	cout << endl;
//}
//int main()
//{
//	vector<int> v = {1,2,3,4,5,6,7};
//	vector<double> v1 = {1.1,2.2,3.3,4.4,5.5,6.6,7.7};
//	int i = 1;
//	int j = { 1 };
//	int k  { 1};
//	printvector(v);
//	printvector(v1);
//	return 0;
//}
//// 类模板
//template<class T1, class T2>
//class Data
//{
//public:
//	Data() { cout << "Data<T1, T2>-原模板" << endl; }
//private:
//	T1 _d1;
//	T2 _d2;
//};
//
//// 特化：针对某些特殊类型，进行特殊化处理
//// 全特化
//template<>
//class Data<int, char>
//{
//public:
//	Data() { cout << "Data<int, char>- 全特化" << endl; }
//};
////偏特化 /半特化
//template<class T1>
//class Data<T1, char>
//{
//public:
//	Data() { cout << "Data<T1, char>- 半特化" << endl; }
//};
////两个参数偏特化为指针类型 
//template <typename T1, typename T2>
//class Data <T1*, T2*>
//{
//public:
//	Data() { cout << "Data<T1*, T2*>" << endl; }
//
//private:
//	T1 _d1; T2 _d2;
//};
//template <typename T1, typename T2>
//class Data <T1&, T2&>
//{
//public:
//	Data(const T1&d1,const T2& d2)
//		:_d1(d1)
//		,_d2(d2)
//	{ cout << "Data<T1&, T2&>" << endl; }
//
//private:
//	const T1 &_d1;const T2& _d2;
//};
//template<class T>
//bool Less(const T &left,const T & right)
//{
//	return left < right;
//}
//
////对Less函数模板进行特化
//template<>
//bool Less<Date*>(Date* const  & left, Date* const  &right)
//{
//return *left < *right;
// }
//bool Less(Date* left, Date* right)
//{
//	return *left < *right;
//}
 //int main()
 //{
	// Data<int, int>d1;
	// Data<int, char>d2;
	// Data<double, char>d3;
	// Data<int*, int*>d4;
	// Data<int&, int&> d5(1,2);
	// return 0;
 //}
//#include"func.h"
//int main()
//{
//	cout << Add(1, 2)<<endl;
//	cout <<Add(1.1, 2.0)<<endl;
//	func();
//	return 0;
//}

//class Person
//{
//public:
//	void Print()
//	{
//		cout << "name:" << _name << endl;
//		cout << "age:" << _age << endl;
//		cout << _tel << endl;
//	}
//
//	string _name = "peter"; // 姓名
//protected:
//	int _age = 18; // 年龄
//private:
//	int _tel = 110;
//};
//class Student : public Person
//{
//	
//protected:
//	int _stuid; // 学号
//};
//class Teacher : public Person
//{
//protected:
//	int _jobid; // 工号
//};
//int main()
//{
//	Person p;
//	Student s;
//	s._name = "张三";
//	s._age = 25;
//	s._tel = 10;
//	s.Print();
//	p.Print();
//	return 0;
//} 

//int main()
//{
//	//类型转换 会产生临时变量
//	int i = 1234;
//	printf("%x\n",i);
//	//截断
//	char ch = i;
//	printf("%x\n",ch);
//    //提升
//	i = ch;
//	printf("%x\n",i);
//
//	const int& ref = i;//需要用const修饰 此时的i经过类型转换产生了临时变量具有常性
//	return 0;
//}
//int main()
//{   //基类和派生类的赋值转换
//	Student s;
//	Person p;
//
//	p = s;
//	Person* ptr = &s;//可以给指针也可以给引用
//	Person& ref = s;
//
//	ptr->_name += 'x';
//	ref._name += 'y';
//	s._name += 'z';
//
//	return 0;
//}


//class Person
//{
//
//protected:
//	string _name = "小李子"; // 姓名
//	int _num = 111;// 身份证号
//	
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//	    cout << " 身份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};


//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		A::fun();
//		cout << "func(int i)->" << i << endl;
//	}
//};
//
//int main()
//{
//	B s;
//	s.fun();
//	s.fun(1);
//	s.A::fun();
//	return 0
//}

//
//class Person
//{
//
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//		
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//	
//};
// 
//class Student : public Person
//{
//public:
//	Student(const char* name = "lili", int x = 0, const char* address = "xi an")
//		:Person(name)
//		, _x(x)
//		, _address(address)
//
//	{}
//	Student(const Student& st)
//		:Person(st)
//		, _x(st._x)
//		, _address(st._address)
//	{}
//	Student& operator=(const Student& st)
//	{
//		if (this != &st)
//		{
//			Person::operator=(st);
//			_x = st._x;
//			_address = st._address;
//
//		}
//		return *this;
//	}
//	~Student()
//	{
//		Person::~Person();
//
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _x;                                                                                                                              
//	string _address; //学号
//};
//int main()
//{
//	Student s;
//	Student s1("张三" , 5 ,"北京");
//	Student s3 = s1;
//	s = s1;
//	return 0; 
//}

//#include<iostream>
//using namespace std;
//
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);//友元函数
//protected:
//	string _name; // 姓名
//public:
//	static int _count;
//};
//class Student : public Person
//{
//	public:
//	friend void Display(const Person& p, const Student& s);//友元函数
//
//protected:
//	int _stuNum; // 学号
//};
//void Display(const Person& p, const Student& s)
//{ 
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	Display(p,s);
//	cout << Person::_count << endl;
//	return 0;
//}
#include<iostream>
using namespace std;
#include<string>
//class Person
//{
//public:
//	Person() { ++_count; }
//protected:
//	string _name; // 姓名
//public:
//	static int _count; // 统计人的个数。
//};
//int Person::_count = 0;
//
//class Student : public Person
//{
//	
//protected:
//	int _stuNum; // 学号
//};
//
//int main()
//{
//	Person p;
//	Student s;
//
//	cout << &Person::_count << endl;
//	cout << &Student::_count << endl;
//
//	return 0;
//}

//class Person
//{
//public:
//	string _name; // 姓名
//};
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职工编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//void Test()
//{
//	Assistant a;
//	a._name = "peter";
//}
//class Person {
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//
//};
//void Func(Person p)
//{
//	p.BuyTicket();
//}
//int main()
//{
//	Person p;
//	Student s;
//
//	Func(p);
//	Func(s);
//
//	return 0;
//}

//class Person {
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//
//};
//void Func(Person * p)
//{
//	p->BuyTicket();
//}
//int main()
//{
//	Person p;
//	Student s;
//
//	Func(&p);
//	Func(&s);
//
//	return 0;
//}
//
//class A {};
//class B : public A
//{};
//class Person {
//public:
//	virtual A* BuyTicket() {
//		cout << "买票-全价" << endl; return 0;
//	}
//};
//class Student : public Person {
//public:
//	B* BuyTicket() { cout << "买票-半价" << endl; return 0; }
//
//};
//class Soildor : public Person {
//public:
//	B* BuyTicket() { cout << "买票-优先" << endl; return 0; }
//
//};
//
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//int main()
//{
//	Person p;
//	Student s;
//	Soildor so;
//	Func(p);
//	Func(s);
//	Func(so);
//	
//	return 0;
//}
// 
//
//class Person final 
//{
//public:
//	virtual ~Person()  { cout << "~Person()" << endl; }
//};
//
//class Student : public Person {
//public:
//	~Student()  { delete _ptr; cout << "~Student()" << _ptr <<endl; }
//protected:
//	int* _ptr = new int[10];
//};
//int main()
//{
//	Person* p = new Student;
//	delete p;
//	return 0;
//}


//class Car
//{
//public:
//	virtual void Drive() = 0;
//};
//class Benz :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "Benz-舒适" << endl;
//	}
//};
//class BMW :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "BMW-操控" << endl;
//	}
//};
//void Test()
//{
//	Car* pBenz = new Benz;
//	
//}
//
//int main()
//{
//	return 0;
//}

//class A
//{
//public:
//	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
//	virtual void test() { func(); }
//};
//
//class B : public A
//{
//private:
//	void func(int val ) { std::cout << "B->" << val << std::endl; }
//};
//
//int main(int argc, char* argv[])
//{
//	B* p = new B;
//	p->test();
//	return 0;
//}
#include<iostream>
using namespace std;
//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Func1()" << endl;
//	}
//private:
//	int _b = 1;
//};
//
//int main()
//{
//    Base b;
//	cout << sizeof(b) << endl;
//	return 0;
//}


class Base
{
public:
	/*virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}*/
private:
	int _b = 1;
};
//class Derive : public Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Derive::Func1()" << endl;
//	}
//private:
//	int _d = 2;
//};
int main()
{
	Base b;
	//Derive d;
	/*printf("%p\n",&Base::Func1);
	printf("%p\n", &Base::Func2);
	printf("%p\n", &Base::Func3);*/
	int a = 1;

	return 0;
}